#ifndef __M_CONF_H__
#define __M_CONF_H__

#include "util.hpp"
#include <mutex>

namespace Cloud
{
#define CONFIG_FILE "./cloud.conf"

    // 配置信息加载类（单例）
    class Config
    {
    public:
        // 获取单例对象句柄
        static Config* GetInstance()
        {
            // 双检查加锁
            if(_instance == nullptr)
            {
                _mtx.lock();
                if(_instance == nullptr)
                {
                    // 首次创建
                    _instance = new Config;
                }
                _mtx.unlock();
            }

            return _instance;
        }

        // 获取成员信息
        int GetHotTime()
        {
            return _hot_time;
        }

        std::string GetServerIP()
        {
            return _server_ip;
        }

        int GetServerPort()
        {
            return _server_port;
        }

        std::string GetDownLoadPrefix()
        {
            return _download_prefix;
        }

        std::string GetPackFileSuffix()
        {
            return _packfile_suffix;
        }

        std::string GetPackFileDir()
        {
            return _packfile_dir;
        }

        std::string GetBackupFile()
        {
            return _backup_file;
        }

        std::string GetBackFileDir()
        {
            return _backfile_dir;
        }

    private:
        // 构造私有化
        Config() 
        {
            LoadConfigFile();
        }

        Config(const Config&); // 拷贝构造私有化

        // 加载配置文件信息
        bool LoadConfigFile(std::string filename = CONFIG_FILE)
        {
            // 读取文件
            FileUtil fu(filename);
            std::string body;
            if(fu.GetContent(&body) == false)
            {
                std::cout << "Load config file fail!" << std::endl;
                return false;
            }

            // 反序列化
            Json::Value root;
            if(JsonUtil::UnSerialization(body, &root) == false)
            {
                std::cerr << "UnSerialization config file fail!" << std::endl;
                return false;
            }

            // 填充配置信息
            _hot_time = root["hot_time"].asInt();
            _server_ip = root["server_ip"].asString();
            _server_port = root["server_port"].asInt();
            _download_prefix = root["download_prefix"].asString();
            _packfile_suffix = root["packfile_suffix"].asString();
            _packfile_dir = root["packfile_dir"].asString();
            _backup_file = root["backup_file"].asString();
            _backfile_dir = root["backfile_dir"].asString();

            return true;
        }

    private:
        static Config *_instance; // 指向单例对象的指针
        static std::mutex _mtx; // 确保多线程并发访问时的安全性
    private:
        // 具体配置信息成员
        int _hot_time; // 热点时间
        std::string _server_ip; // 服务器IP
        int _server_port; // 服务器端口
        std::string _download_prefix; // 请求下载资源前缀
        std::string _packfile_suffix; // 压缩文件后缀
        std::string _packfile_dir; // 压缩文件存放路径（目录）
        std::string _backup_file; // 服务器备份信息的存放文件
        std::string _backfile_dir; // 备份文件存放路径（目录）
    };

    // 初始化静态成员
    Config* Config::_instance = nullptr; 
    std::mutex Config::_mtx;
}

#endif